#!/bin/bash
#Grupo01

#--------------------------------------------------------------------------------------------------------------------
#Validacion Inicializacion de ambiente
#--------------------------------------------------------------------------------------------------------------------

if [ -z "$INICIART_INICIALIZADO" ]; then
	#LoguearT.pl "GrabarParqueT" "SE" "El entorno no ha sido inicializado" "GrabarParqueT"
	echo "GrabarParqueT - Inicializacion del ambiente no fue exitosa. El entorno no ha sido inicializado"
	exit 1
else
	LoguearT.pl "GrabarParqueT" "I" "$ENTORNO_INIT" "GrabarParqueT"
fi



#--------------------------------------------------------------------------------------------------------------------
# Defino la variable de entorno si GrabarParqueT esta en ejecucion
#--------------------------------------------------------------------------------------------------------------------


# Validacion de que no se este ejecutando otra instancia de este comando
comandoEjecutar="GrabarParqueT"
pid=0

pid=`ps ax | grep $comandoEjecutar | grep -v grep | wc -l`

mensaje_log=`echo "$CANT_PROC" | sed "s/&1/$pid /g"`
LoguearT.pl "GrabarParqueT" "I" "$mensaje_log" "GrabarParqueT"
if [ $pid -gt 2 ]
     then
     LoguearT.pl "GrabarParqueT" "SE" "$CMD_YA_EXEC" "GrabarParqueT"
     exit 1
fi

#--------------------------------------------------------------------------------------------------------------------
#Defino RegEx
#--------------------------------------------------------------------------------------------------------------------
#
# Defino regex para Customer Id
#
cusidRegex="^[0-9]+$";
#
# Defino regex para Commercial plan Id
#
cpidRegex="^[0-9]+$";
#
# Defino regex para Class Service Id
#
csidRegex="^[0-9]+$";
#
# Defino regex para Class Service is required
#
csirRegex="[YN]{1}";
#
# Defino regex para Item Id
#
itidRegex="^[0-9]+$";

#--------------------------------------------------------------------------------------------------------------------
# Defino Variables Globales
#--------------------------------------------------------------------------------------------------------------------
# Campos Cabecera/Detalle

#Id del Cliente
CUSTOMER_ID="";

# Fecha de Operacion
OPERATION_DATE="";

#Id del Plan Comercial
COMMERCIAL_PLAN_ID="";

#Id Clase servicio	
CLASS_SERVICE_ID="";

#Clase de Servicio requerida
CLASS_SERVICE_IS_REQUIRED="";

#Id del Item de Producto
ITEM_ID="";

#--------------------------------------------------------------------------------------------------------------------
# Funcion que valida si el archivo ya fue procesado anteriormente
#--------------------------------------------------------------------------------------------------------------------
function verificarDuplicidad(){
	VALIDO=0
	
	if [ -f "$INSTPROC$ARCHIVO_SIN_PATH"".0" ]; then
	VALIDO=35

        mensaje_log=`echo "$ARCH_DUP" | sed "s/&1/$ARCHIVO_SIN_PATH/g"`
	LoguearT.pl "verificarDuplicidad" "A" "$mensaje_log" "GrabarParqueT"

	
        MoverT.sh "$INSTRECI$ARCHIVO" "$RECHDIR"
	ret="$?"
	if [ "$ret" -eq "0" ]
	then
		#mensaje_log=`echo "$ARCH_MOV" | sed "s/&1/$ARCHIVO a $RECHDIR/g"`
		LoguearT.pl "MoverT" "I" "Se movio el archivo $ARCHIVO a $RECHDIR" "GrabarParqueT"
	else
		#mensaje_log=`echo "$ARCH_NO_MOV" | sed "s/&1/$ARCHIVO a $RECHDIR/g"`			
		LoguearT.pl "MoverT" "SE" "No se pudo mover el archivo $ARCHIVO a $RECHDIR" "GrabarParqueT"
		return 1
	fi

	return 1

    fi
	return 0

}

#--------------------------------------------------------------------------------------------------------------------
# Funcion que ordena el archivo y lo mueve a procesado
#--------------------------------------------------------------------------------------------------------------------
function ordenarArchivo(){

	#Ordenar archivo 	
	 sort -t, -nk1 -dk2 -nk3 -k5,5r  "$INSTRECI$ARCHIVO_SIN_PATH" -o"$INSTRECI$ARCHIVO_SIN_PATH"
	mensaje_log=`echo "$ARCH_ORD" | sed "s/&1/$INSTRECI$ARCHIVO_SIN_PATH/g"`
	LoguearT.pl "ordenarArchivo" "I" "$mensaje_log" "GrabarParqueT"
	
	#Copio file ordenado a dir de ordenados
	cp -f "$INSTRECI$ARCHIVO_SIN_PATH" "$INSTORDE"
	#mensaje_log=`echo "$ARCH_COP" | sed "s/&1/$ARCHIVO_SIN_PATH a $INSTORDE/g"`
	LoguearT.pl "ordenarArchivo" "I" "No se pudo mover el archivo $ARCHIVO_SIN_PATH a $INSTORDE" "GrabarParqueT"

	#Se mueve el file al dir de procesados, para evitar su posterior procesamiento
	#echo "Mover file $INSTRECI$ARCHIVO a $INSTPROC"
	MoverT.sh "$INSTRECI$ARCHIVO" "$INSTPROC"
	ret="$?"
	if [ "$ret" -eq "0" ]
	then
		#mensaje_log=`echo "$ARCH_MOV" | sed "s/&1/$ARCHIVO_SIN_PATH a $INSTPROC/g"`
		LoguearT.pl "MoverT" "I" "Se movio el archivo $ARCHIVO_SIN_PATH a $INSTPROC" "GrabarParqueT"
	else
		#mensaje_log=`echo "$ARCH_NO_MOV" | sed "s/&1/$ARCHIVO_SIN_PATH a $INSTPROC/g"`
		LoguearT.pl "MoverT" "SE" "No se pudo mover el archivo $ARCHIVO_SIN_PATH a $INSTPROC" "GrabarParqueT"
	fi

	 

}

#--------------------------------------------------------------------------------------------------------------------
# Funcion que parsea un registro
#--------------------------------------------------------------------------------------------------------------------
function parsear_registro()
{
	local valido=0;	
	registroParsear=$1;
	#
	# Obtengo campo #Id del Cliente
	#
	CUSTOMER_ID=`echo "$registroParsear" | awk -F ',' ' { print $1 } '`;
	#echo "Cliente id= $CUSTOMER_ID"
	#
	# Obtengo campo Fecha de Operacion
	#
	OPERATION_DATE=`echo "$registroParsear" | awk -F ',' ' { print $2 } '`;
	#echo "Fecha= $OPERATION_DATE"
	#
	# Obtengo campo Id del Plan Comercial
	#
	COMMERCIAL_PLAN_ID=`echo "$registroParsear" | awk -F ',' ' { print $3 } '`;
	#echo "Plan is= $COMMERCIAL_PLAN_ID"
	#
	# Obtengo campo Id Clase servicio
	#
	CLASS_SERVICE_ID=`echo "$registroParsear" | awk -F ',' ' { print $4 } '`;
	#echo "Class service is= $CLASS_SERVICE_ID

	#
	# Obtengo campo Clase de Servicio requerida
	#
	CLASS_SERVICE_IS_REQUIRED=`echo "$registroParsear" | awk -F ',' ' { print $5 } '`;
	#echo "Class service required=$CLASS_SERVICE_IS_REQUIRED"
		#echo  "Class service is required=$CLASS_SERVICE_IS_REQUIRED"
		if [ "$CLASS_SERVICE_IS_REQUIRED" == "Y" ]
		then	
			cabeceraLeida=1
			#echo "Cabecera leida"
		else

			cabeceraLeida=0
		fi

	#
	# Obtengo campo Id del Item de Producto
	#
	IFS=$OIFS
	ITEM_ID=`echo "$registroParsear" | awk -F ',' ' { print $6 } '`;
	#echo "item id= $ITEM_ID"
	OIFS=$IFS
IFS="
"

	return $valido;
}

#--------------------------------------------------------------------------------------------------------------------
# Funcion que valida obligatiorios
#--------------------------------------------------------------------------------------------------------------------
function valido_obligatorios()
{
	local valido=0;	
	registroParsear=$1;
	#
	# Obtengo campo #Id del Cliente
	#

	if [ -z  "$CUSTOMER_ID" ]
		then 
			valido=1
			mensaje_log=`echo "$CAMPO_OBL" | sed "s/&1/CUSTOMER_ID/g"`
			LoguearT.pl "valido_obligatorios" "E" "$mensaje_log" "GrabarParqueT"
			MOTIVO="CUSTOMER_ID no informado"
	fi
	#
	# Obtengo campo Fecha de Operacion
	#

	if [ -z  $OPERATION_DATE ]
		then 
			valido=1
			mensaje_log=`echo "$CAMPO_OBL" | sed "s/&1/OPERATION_DATE/g"`
			LoguearT.pl "valido_obligatorios" "E" "$mensaje_log" "GrabarParqueT"
			MOTIVO="OPERATION_DATE no informado"
	fi
	#
	# Obtengo campo Id del Plan Comercial
	#
	
	if [ -z  $COMMERCIAL_PLAN_ID ]
		then 
			valido=1
			mensaje_log=`echo "$CAMPO_OBL" | sed "s/&1/COMMERCIAL_PLAN_ID/g"`
			LoguearT.pl "valido_obligatorios" "E" "$mensaje_log" "GrabarParqueT"
			MOTIVO="COMMERCIAL_PLAN_ID no informado"
	fi
	#
	# Obtengo campo Id Clase servicio
	#

	if [ -z  $CLASS_SERVICE_ID ]
		then 
			valido=1
			mensaje_log=`echo "$CAMPO_OBL" | sed "s/&1/CLASS_SERVICE_ID/g"`
			LoguearT.pl "valido_obligatorios" "E" "$mensaje_log" "GrabarParqueT"
			MOTIVO="CLASS_SERVICE_ID no informado"
	fi

	#
	# Obtengo campo Clase de Servicio requerida
	#

	if [ -z  "$CLASS_SERVICE_IS_REQUIRED" ]
		then 
			valido=1
	#		#echo "Class service required=$CLASS_SERVICE_IS_REQUIRED"
			mensaje_log=`echo "$CAMPO_OBL" | sed "s/&1/CLASS_SERVICE_IS_REQUIRED/g"`
			LoguearT.pl "valido_obligatorios" "E" "$mensaje_log" "GrabarParqueT"
			MOTIVO="CLASS_SERVICE_IS_REQUIRED no informado"
			
	

	fi
	#
	# Obtengo campo Id del Item de Producto
	#
	#echo "Item id= $ITEM_ID"
	if [ -z $ITEM_ID ]
		then 
			#echo "Item invalido"
			valido=1
			mensaje_log=`echo "$CAMPO_OBL" | sed "s/&1/ITEM_ID/g"`
			LoguearT.pl "valido_obligatorios" "E" "$mensaje_log" "GrabarParqueT"	
			MOTIVO="ITEM_ID no informado"

	fi
	return $valido;
}

#--------------------------------------------------------------------------------------------------------------------
# Funcion que valida un registro fisico
#--------------------------------------------------------------------------------------------------------------------
function valido_formato_campos()
{
	#
	# Asumo registro valido
	#
	local registroValido=0;

	#
	# Valido Id del Cliente
	#
	if [[ $CUSTOMER_ID =~ $cusidRegex ]]
	then
		val=0

	else
		registroValido=1;
		
		mensaje_log=`echo "$FORMATO_INV" | sed "s/&1/Customer id/g"`
		LoguearT.pl "valido_formato_campos" "E" "$mensaje_log" "GrabarParqueT"
		MOTIVO="Formato Customer id invalido"
	fi;

	#
	# Valido  Fecha de Operacion
	#
	if [ -n "$OPERATION_DATE" ]
	then
		. ValidarFechaFormato.sh "$OPERATION_DATE"
		local ret="$?"		
		if [ "$ret" -ne "0" ]
		then
			#echo "formato fecha invalido"
			mensaje_log=`echo "$FORMATO_INV" | sed "s/&1/Operation date/g"`
			LoguearT.pl "valido_formato_campos" "E" "$mensaje_log" "GrabarParqueT"
			MOTIVO="Formato Operation date invalido"
			registroValido=1;
		fi;
	fi

	#
	# Valido id del Plan
	#
        #echo "$COMMERCIAL_PLAN_ID"
        if [[ $COMMERCIAL_PLAN_ID =~ $cpidRegex ]]
	then
		val=0
               # echo "formato Plan id valido"
	else
		registroValido=1;
		#echo "formato C Plan id invalido"
		mensaje_log=`echo "$FORMATO_INV" | sed "s/&1/ID Plan Comercial/g"`
                LoguearT.pl "valido_formato_campos" "E" "$mensaje_log" "GrabarParqueT"
		MOTIVO="Formato ID Plan Comercial invalido"

		
	fi;
        #
	# Valido Id Clase servicio
	#
	#echo "class service id $CLASS_SERVICE_ID"
	if [[ $CLASS_SERVICE_ID =~ $csidRegex ]]
	then
		val=0
	else
		registroValido=1;
		#echo "class service id invalido"
		mensaje_log=`echo "$FORMATO_INV" | sed "s/&1/Class Service id/g"`
		LoguearT.pl "valido_formato_campos" "E" "$mensaje_log" "GrabarParqueT"
		MOTIVO="Formato Class Service id invalido"
	fi;

	#
	# Valido Clase de Servicio requerida
	#
	if [[ $CLASS_SERVICE_IS_REQUIRED =~ $csirRegex ]]
	then

		val=0
	else
		registroValido=1;
		 #echo "Clase servicio requerido id invlido"
		mensaje_log=`echo "$FORMATO_INV" | sed "s/&1/Class service is required/g"`
		LoguearT.pl "valido_formato_campos" "E" "$mensaje_log" "GrabarParqueT"
		MOTIVO="Formato Class service is required invalido"
		
	fi;

	#
	# Valido item Id
	#
	if [[ $ITEM_ID =~ $itidRegex ]]
	then
		val=0	
	else
		registroValido=1;
		#echo "Item id invalido"
		mensaje_log=`echo "$FORMATO_INV" | sed "s/&1/Item id/g"`
		LoguearT.pl "valido_formato_campos" "E" "$mensaje_log" "GrabarParqueT"
		MOTIVO="Formato Item id invalido"
		
	fi;


	return $registroValido;
}

#--------------------------------------------------------------------------------------------------------------------
# Funcion que valida un registro logico
#--------------------------------------------------------------------------------------------------------------------
function valido_datos_campos()
{
	#
	# Considero registro valido
	#
	local registroValido=0;

	#
	# Busco Id de Cliente
	#
	#echo "Clientes $CUSTOMER_ID"
#	#echo "Maestro Clientes $MAEDIR$clientes"
	cliente="cli.mae"
	local idClienteMaestro=`cat $MAEDIR$cliente | cut -d";" -f1 | grep "$CUSTOMER_ID"`;
	#echo "Cliente leido $idClienteMaestro "

	if [ -z "$idClienteMaestro" ]
	then
		LoguearT.pl "valido_datos_campos" "E" "$NO_EXIST_CLIENTE $CUSTOMER_ID" "GrabarParqueT"
		MOTIVO="Cliente no existe en maestro $CUSTOMER_ID"
		registroValido=1;
		#echo "No existe cliente $CUSTOMER_ID"
	else
		#
		# Valido Operation data
		#
		. ValidarFecha.sh "$OPERATION_DATE"
		local ret="$?"
		
		#echo "salida validar fecha $ret"
		if [ "$ret" -ne "0" ]
		then
			LoguearT.pl "valido_datos_campos" "E" "$FECHA_INV $OPERATION_DATE" "GrabarParqueT"
			registroValido=1;
			MOTIVO="Fecha de operacion invalida $OPERATION_DATE"
		#	#echo "Fecha Mayor a la actual"
		else

		        #
		        # Valido Id Plan Comercian + Id Clas de Servicio + Id del Item
		        prod="prod.mae"
		        #echo "$COMMERCIAL_PLAN_ID + $CLASS_SERVICE_ID + $ITEM_ID"
		        #local lineas=`cat $MAEDIR$prod | grep "$COMMERCIAL_PLAN_ID" | grep "$CLASS_SERVICE_ID" | grep "$ITEM_ID" | wc -l`
                        #echo "$lineas"
		        #if [ "$lineas" -eq "0" ]
                        descrip=`awk -F , '{ if ( $3 == '" $COMMERCIAL_PLAN_ID "' && $5 == '" $CLASS_SERVICE_ID "' && $8 == '" $ITEM_ID "' )
			print $9 }' $MAEDIR$prod`
                        if [ -z "$descrip" ]			
			then
			 LoguearT.pl "valido_datos_campos" "E" "Invalido Id Plan Comercian + Id Clas de Servicio + Id del Item" "GrabarParqueT"				
			  MOTIVO="Invalido Id Plan Comercian + Id Clas de Servicio + Id del Item"
			  registroValido=1;
			fi
		fi;
fi;

	return $registroValido;
}

#--------------------------------------------------------------------------------------------------------------------
# Guardar Registro rechazado
#--------------------------------------------------------------------------------------------------------------------
function guardarBloqueRechazados(){

	# Escribo el registro
	#
	#echo "Guardo Reg rechazado $1"
	today=`date +'%m/%d/%Y %H:%M %p'`
	
	echo "$today - $MOTIVO  - $1" >> "$INSTRECH$archivo"
	let "CANT_ARCHIVOS_NOK = CANT_ARCHIVOS_NOK + 1"		
	
return 0

}

#--------------------------------------------------------------------------------------------------------------------
# Funcion que Valida Bloque
#--------------------------------------------------------------------------------------------------------------------

function valido_bloque(){

	local reg=$1
	local regc=$2
		
		#Valido Secuencia Cabecera- Detalle C-D-C-D 
		#echo "Anterior Leido= $anteriorleido"
		if [  $anteriorleido -eq 0 ]
		then		
			#Si anterior detalle y actual detalle ->Rechazado		
			if [  $cabeceraLeida -eq 0 ]	
				then 
					MOTIVO="Bloque Invalido Falta cabecera"					
					guardarBloqueRechazados "$reg"
					#echo "D rechazados bloque 1"
					LoguearT.pl "valido_bloque" "E" "$REG_INV $reg" "GrabarParqueT"				
										
					return 1			
			fi

		else
			#echo "Primer Reg Leido"
			#Si es el primer reg y es Detalle ->Rechazado		
			if [[ $anteriorleido -eq 2 && $cabeceraLeida -eq 0 ]]
				then 
					MOTIVO="Bloque Invalido Falta cabecera"					
					guardarBloqueRechazados "$reg"
					LoguearT.pl "valido_bloque" "E" "$REG_INV $reg" "GrabarParqueT"
						
					return 1
						#Si anterior cabecera y actual cabecera ->Rechazados
			elif [[ $anteriorleido -eq 1 &&  $cabeceraLeida -eq 1 &&  $c_invalida -eq 0 ]]	
				then 
					MOTIVO="Bloque Invalido Falta detalle"						
					guardarBloqueRechazados "$regc"
					LoguearT.pl "valido_bloque" "E" "$REG_INV $regc" "GrabarParqueT"
					#echo "C rechazado bloque"
					
					return 1
			fi
		fi


	return 0
}

#--------------------------------------------------------------------------------------------------------------------
# Funcion que Chequea la validez del reg
#--------------------------------------------------------------------------------------------------------------------

function chequear_reg_validez(){


		#Reg Invalido
		if [ $registroValidado -eq 1 ]
		 then
			 #echo "Reg Invalido $regritro"	
		 	 #Seteo flag de lectura cabecera invalida

			 motivo_aux=$MOTIVO			
    			 if [ $cabeceraLeida -eq 1  ]		
			    then		
				c_invalida=1
                         fi
			 #Si el detalle esta mal y la cabecera fue valida, guardo cabecera primero
			 if [ $cabeceraLeida -eq 0  -a $c_invalida -eq 0 ]
			   then	
			       
			       MOTIVO="Detalle invalido"			 
			       guardarBloqueRechazados "$registroc"
			       LoguearT.pl "chequear_reg_validez" "E" "$REG_INV $reg" "GrabarParqueT"
			       	
			 fi
			#Guardo reg invalido
			MOTIVO=$motivo_aux
			guardarBloqueRechazados "$registro"
			LoguearT.pl "chequear_reg_validez" "E" "$REG_INV $registro" "GrabarParqueT"
                    
		#Si fue valiod			
		else					 
                        #Si es detalle valido y la cabecera fue invalida guardo detalle como invalido
			if [ $cabeceraLeida -eq 0 -a $c_invalida -eq 1 ]
			  then		
				MOTIVO="Cabecera invalida"
				guardarBloqueRechazados $registro
				LoguearT.pl "chequear_reg_validez" "E" "$REG_INV $registro" "GrabarParqueT"
			 else			   
			#Si cabecera y detalle fueron validas, chequeo q sean del mismo cliente y condiciones, sino las rechazo
				if [ $cabeceraLeida -eq 0 ]
				then
                                        local customer=`echo "$registroc" | awk -F ',' ' { print $1 } '`;
					#echo "CustomerId=$customer"
					if [ "$customer" != "$CUSTOMER_ID" ] 
					then
						if [ ! -z "$customer" ]						                          
                                                 then												
							MOTIVO="Customer distinto"							
							guardarBloqueRechazados "$registroc"
							LoguearT.pl "chequear_reg_validez" "E" "$REG_INV $registroc" "GrabarParqueT"
						fi
					       guardarBloqueRechazados "$registro"
					       LoguearT.pl "chequear_reg_validez" "E" "$REG_INV $registro" "GrabarParqueT"
					else
						#echo "Guardo bloque valido"
						guardofilevalido "$registroc" "$registro" 
						LoguearT.pl "chequear_reg_validez" "I" "Bloque Valido" "GrabarParqueT"
					fi

				fi
	
  			 fi			  		 
						
		fi

return 0

}

#--------------------------------------------------------------------------------------------------------------------
# Guardar bloque OK
#--------------------------------------------------------------------------------------------------------------------
#$1 = Registro cabecera
#$2 = Registro detalle
function guardofilevalido(){
	#echo "Guardo Registros Instalados"
	let "CANT_ARCHIVOS_OK = CANT_ARCHIVOS_OK + 2"

	#busca tipo de producto con el COMMERCIAL PLAN ID
	PRODUCT_TYPE_ID=`cat $MAEDIR$prod | cut -d"," -f2-3 | grep "[,]$COMMERCIAL_PLAN_ID$" | cut -d"," -f1 | sort -u`
	#borro el \n del final


	#Busca el ID de sucursal, sacandolo del nombre del archivo
	ID_SUCURSAL=`echo "$ARCHIVO_SIN_PATH" | awk -F '-' ' { print $2 } '`
        ID_SUCURSAL=`echo "$ID_SUCURSAL" | awk -F '.' ' { print $1 } '`
	#echo "Sucursal: $ID_SUCURSAL"

	#Busca descripciòn del producto de cabecera
	PLAN_ID_C=`echo "$1" | awk -F ',' ' { print $3 } '`
	SERVICEID_C=`echo "$1" | awk -F ',' ' { print $4 } '`
	ITEM_ID_C=`echo "$1" | awk -F ',' ' { print $6 } '`
	#DESCRP_C=`cat $MAEDIR$prod | grep $PLAN_ID_C | grep $SERVICEID_C | grep $ITEM_ID_C | cut -d"," -f9`
	DESCRP_C=`awk -F , '{ if ( $3 == '" $PLAN_ID_C "' && $5 == '" $SERVICEID_C "' && $8 == '" $ITEM_ID_C "' )
			print $9 }' $MAEDIR$prod`
        #echo "Decripcion cabecera: $DESCRP_C"
	
        #Busca descripciòn del producto de detalle
	PLAN_ID_D=`echo "$2" | awk -F ',' ' { print $3 } '`
	SERVICEID_D=`echo "$2" | awk -F ',' ' { print $4 } '`
	ITEM_ID_D=`echo "$2" | awk -F ',' ' { print $6 } '`
	#DESCRP_D=`cat $MAEDIR$prod | grep $PLAN_ID_D | grep $SERVICEID_D | grep $ITEM_ID_D | cut -d"," -f9`
	DESCRP_D=`awk -F , '{ if ( $3 == '" $PLAN_ID_D "' && $5 == '" $SERVICEID_D "' && $8 == '" $ITEM_ID_D "' )
			print $9 }' $MAEDIR$prod`
        #echo "Decripcion Detalle: $DESCRP_D"
	
        #Guarda registro dependiendo del tipo de producto, separando campos por ","
	coma=","
	#echo "Se guarda en $INSTPARQUE$PRODUCT_TYPE_ID"
	LoguearT.pl "guardofilevalido" "I" "Se guarda reg valido $INSTPARQUE$PRODUCT_TYPE_ID" "GrabarParqueT"
	IFS=$OIFS
	echo -e "$ID_SUCURSAL$coma$CUSTOMER_ID$coma$DESCRP_C$coma$DESCRP_D" >> "$INSTPARQUE$PRODUCT_TYPE_ID"
	OIFS=$IFS
IFS="
"

}
#--------------------------------------------------------------------------------------------------------------------
# Funcion que procesa el file
#--------------------------------------------------------------------------------------------------------------------

function procesarArchivo(){

	# Inicializo el numero de registro del archivo actual
	#
	numeroRegistro=0;
	registroc="";		
	c_invalida=0;	

	#
	# Itero por cada registro del archivo actual
	for registroIterado in `cat $INSTPROC$archivop`
	do
		registro=$registroIterado;
		#echo "registro=$registroIterado"
		LoguearT.pl "procesarArchivo" "I" "Procesando reg= $registro" "GrabarParqueT"
		# Incremento el numero de registro del archivo actual
		#
		#numeroRegistro=`echo "$numeroRegistro + 1" | bc`;
		let numeroRegistro=$numeroRegistro+1
		# Calculo cantidad de campos del registro
		#
		cantidadCampos=`echo "$registro" | awk -F',' ' { print NF } '`;	
		# Valido cantidad de campos del registro
		#
		if [ $cantidadCampos -ne 6 ]
		then
			registroValidado=1;
			#numeroRegInvalidos=`echo "$numeroRegInvalidos + 1" | bc`;
			if [ $cantidadCampos -lt 6 ]	
			 then	
				LoguearT.pl "procesarArchivo" "E" "Cantidad de campo campos faltantes" "GrabarParqueT"
				MOTIVO="Cantidad de campo campos faltantes"
			 else
				LoguearT.pl "procesarArchivo" "E" "Cantidad de campo campos excedentes" "GrabarParqueT"
				MOTIVO="Cantidad de campo campos excedentes"
			fi
			guardarBloqueRechazados $registro
		else

		
			#Parsero registro
			#echo "Muestro reg actual $registro"
			LoguearT.pl "procesarArchivo" "I" "Parseo de registro" "GrabarParqueT"
			parsear_registro $registro
			ret="$?"
		
			#Valido Bloque
			#echo "Cabecera Leida=$cabeceraLeida"
			LoguearT.pl "procesarArchivo" "I" "Validar nivel bloque" "GrabarParqueT"
			valido_bloque $registro $registroc 
			ret="$?"
                 
 			#echo "cabecera=$cabeceraLeida"
			if [ $cabeceraLeida -eq 1 ]
			then
					#guardo cabecera
					registroc=$registro
        	                        c_invalida=0
			fi
	
			#echo "Validar Bloque = $ret"
			if [ "$ret" -eq "1"  ]
			then
			registroValidado=2
			else
				
				# Considero registro valido
				#
				registroValidado=0;

				#Valido campos Obligatorios
				LoguearT.pl "procesarArchivo" "I" "Validar obligatorios" "GrabarParqueT"
				valido_obligatorios $registro
				ret="$?"
				# Valido registro fisico
				#
				if [ "$ret" -eq "0" ]
				then	
					LoguearT.pl "procesarArchivo" "I" "Validar formato" "GrabarParqueT"
					valido_formato_campos	
					ret="$?"
					if [ "$ret" -ne "0" ]
					then
						registroValidado=1;
						#echo "fisico invalido $?"
					else
						#echo "fisico valido $?"
				# Valido registro logico
				#               
                                                #echo "entra a validad"
						LoguearT.pl "procesarArchivo" "I" "Validar datos" "GrabarParqueT"
						valido_datos_campos
						registroValidado="$?";
                                                #echo "sale de validar $registroValidado"
					fi
				else 
				   registroValidado=1; 
				fi	
		       #echo "Antes de chequear $registroValidado"
        	       chequear_reg_validez
	
			fi
		#fi

		fi

		registroValidado=0;

		if [ $cabeceraLeida -eq 1 ]
		then
			anteriorleido=$cabeceraLeida
		else
			anteriorleido=2
		fi

	done;
#Si la ultima linea es cabecera	
	if [ $cabeceraLeida -eq 1 -a  $c_invalida -eq 0 ]
    	then
	guardarBloqueRechazados "$registro"
	fi

}

#--------------------------------------------------------------------------------------------------------------------
# Cuerpo principal 
#--------------------------------------------------------------------------------------------------------------------
#
# Almaceno IFS viejo
#
OIFS=$IFS;

#
# Establezco nuevo IFS
#
IFS="
";

actualValido=""
cabeceraLeida=0
anteriorleido=0;
numeroRegValidos=0;
numeroRegInvalidos=0;
ARCH_ORDENADO=0;
CANT_ARCHIVOS_NOK=0;
CANT_ARCHIVOS_OK=0;
MOTIVO="";

# Obtengo el nro de Files recibidos
nroFiles=`ls $INSTRECI | wc -l`

#
# Itero por cada archivo de arridir
#	
listaArchivos=`ls $INSTRECI`;

#Grabo en el log
#echo "nro de archivos $nroFiles"
LoguearT.pl "GrabarParqueT" "I" "Cantidad de archivos a procesar= $nroFiles" "GrabarParqueT"

for archivo in $listaArchivos
	
	do					
		
		ARCHIVO_SIN_PATH="$archivo"
	
		ARCHIVO="$NSTRECI$ARCHIVO_SIN_PATH"
	
		#Guardo en LOG archivo a procesar
		#
		LoguearT.pl "GrabarParqueT" "I" "Archivo a procesar $archivo" "GrabarParqueT"

		#Valido duplicado
		#		
		verificarDuplicidad
		ret="$?"
	    	if [ "$ret" -eq "0" ]
		then		
			#Ordeno Archivo
			#
			let "ARCH_ORDENADO = ARCH_ORDENADO + 1"
			ordenarArchivo
			
			if [ "$ret" -eq "0" ]
			then
				#Proceso Archivo
				#echo "Procesar archivo"	
				archivop="$archivo"".0"     
				procesarArchivo

			fi

		fi


done;
#
# Termine de iterar cada archivo de arridir
#

#Guardo en el Log

#Archivos leidos
LoguearT.pl "GrabarParqueT" "I" "Archivos Leidos $nroFiles" "GrabarParqueT"

#Arhivos procesados
LoguearT.pl "GrabarParqueT" "I" "Archivos Ordenados $ARCH_ORDENADO" "GrabarParqueT"

#Registros Leidos
TOTAL_OK=0
let "TOTAL = CANT_ARCHIVOS_OK + CANT_ARCHIVOS_NO"
LoguearT.pl "GrabarParqueT" "I" "Registros Leidos $TOTAL" "GrabarParqueT"

#Registros Correctos
LoguearT.pl "GrabarParqueT" "I" "Registros Correctos $CANT_ARCHIVOS_OK" "GrabarParqueT"
	
#Registros No Correctos
LoguearT.pl "GrabarParqueT" "I" "Registros Incorrectos $CANT_ARCHIVOS_NOK" "GrabarParqueT"

#Registros Leidos
TOTAL_OK=0
let "TOTAL_P = CANT_ARCHIVOS_OK / 2"
LoguearT.pl "GrabarParqueT" "I" "Parque Instalado $TOTAL_P" "GrabarParqueT"

#Guardar Total Control
CONTROL_TOTAL=0
let "CONTROL_TOTAL = CANT_ARCHIVOS_NOK + CANT_ARCHIVOS_OK"
LoguearT.pl "GrabarParqueT" "I" "Total Control=  $CONTROL_TOTAL" "GrabarParqueT"

#
# Establezco viejo IFS
#
IFS=$OIFS;




